home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / SourceCode / Tutorial / Cookbook / 07.PSWrap / notes < prev    next >
Text File  |  1995-06-12  |  5KB  |  148 lines
  1. Objective:
  2.   To learn how to integrate files that have pure postscript commands.
  3.   To illistrate that variables from the View superclass are accessable.
  4.   
  5. Terms:
  6.    .psw: Postscript wrap files - files with pure ASCII postscript.
  7.    
  8. Discussion:
  9.    By creating a file with the ".psw" extension, we can call complex
  10.    postscript procedures directly from our Objective C programs.
  11.    
  12. Method:
  13. 1) Take the original "line" program and create the file line.psw which
  14.    contains the following lines:
  15.  
  16. defineps doLine(float x,y)
  17.     5 setlinewidth
  18.     newpath
  19.        100 100 moveto
  20.        x y lineto
  21.     stroke
  22. endps
  23.  
  24. Then added the file "line.psw" to the project manager by going to the
  25. Files/Project... menu, selecting Files from the top button and then selecting
  26. .psw files from the pop up menu.  Once .psw Files button is showing we then select the Add... button at the bottum which will bring up an open panel.  We then select the line.psw file.
  27.  
  28. The drawSelf routine is then changed to be the following:
  29.  
  30. - drawSelf:(NXRect*)r :(int)c
  31. {
  32.     PSsetgray(1.0);
  33.     NXRectFill(r);
  34.     PSsetgray(0.0);
  35.     doLine(200.0, 200.0);
  36.     return self;
  37. }
  38.  
  39. We also add the include file "line.h" created from line.psw to the
  40. myView.m file:
  41.  
  42. #import "line.h"
  43.  
  44. When you type "make" you will see the following additional commands get
  45. executed:
  46.  
  47. pswrap  -h line.h -o line.c line.psw
  48. cc -O -Wimplicit -c line.c -o obj/line.o
  49.  
  50. You should still see the line being drawn after you execute line.
  51.  
  52. Part II - finding the center of the view
  53.  
  54. What if you wanted to draw a line from the exact center of the View?
  55. Since the bounds of the view are kept in the View superclass, all we have
  56. to do is use those variables.  This can be done by changing the argument
  57. of the doLine subroutine to be:
  58.  
  59.    doLine(bounds.size.width/2.0, bounds.size.height/2.0);
  60.    
  61. By looking in the Spec Sheet for View we find that the bounds is
  62. kept as a type NXRect.  Every NXRect has an origin and a size.  If
  63. we look in /usr/include/appkit/graphics.h we will find the types of
  64. NXSize is used, which has a height and width.  Although the include file
  65. are complicated, accessing the bounds of any view is not.  All you have
  66. to do is understand where to get the height and width.  Remember, this
  67. was Inherited from the View object.
  68.  
  69. III.  The next step is to add a button to the interface which will
  70. change the view.  To do this, bring up the Interface Builder for
  71. LittleDraw.nib by double clicking on the icon. Add
  72. a button to the lower right hand corner by dragging it from the View
  73. Palette.  Place the button on the main  window just below the
  74. view.  Then bring up the Class Editor by accessing selecting
  75. Windows/Classes... from the main menu.   Select the View class
  76. and you should see "myView" in bold.  Select it and then select
  77. Actions.  Type in the string "myAction:".  The colon must be included.
  78.  
  79. Then select the button and control/click a line and drop it on the
  80. view.  It will then connect it up to the "myAction:" method.  Then save
  81. your new nib file by selecting File/Save from the main menu.
  82.  
  83. Then add the following lines to your "myView.m" file.
  84.  
  85. ---------------------------------------------
  86. - myAction:sender
  87. {
  88.     // printf("myFloat = %f\n", myFloat);
  89.     myFloat += 10.0;
  90.     [self display];
  91.     return self;
  92. }
  93.  
  94. - drawSelf:(NXRect*)r :(int)c
  95. {
  96.     PSsetgray(1.0);
  97.     NXRectFill(r);
  98.     PSsetgray(0.0);
  99.     doLine(bounds.size.width/2.0, bounds.size.height/2.0);
  100.     doLine(2*myFloat, myFloat);
  101.     return self;
  102. }
  103. ---------------------------------------------
  104.  
  105.  
  106. Also add the following two lines to you header file:
  107.  
  108.     float myFloat;
  109. - myAction:sender;
  110.  
  111.  
  112. So it will now look like this:
  113.  
  114. ---------------------------------------------
  115. /* Generated by Interface Builder */
  116.  
  117. #import <appkit/View.h>
  118.  
  119. @interface myView:View
  120. {
  121.     float myFloat;
  122.     id    myOutlet;
  123. }
  124.  
  125. - setMyOutlet:anObject;
  126. - myAction:sender;
  127.  
  128. @end
  129. ---------------------------------------------
  130.  
  131. Note that some of these lines could have been created by the Interface Builder's "Unparse" feature.  We then would have clobbered our drawSelf
  132. method.  By adding this by hand, you will discover that you can add
  133. methods without needing the "unparse" for every update.  Unparse is
  134. often be used only initially to create templates.
  135.  
  136. What we did by including the myFloat declaration is to add a new state
  137. variable to the myView object.  Type make in a shell.  When you start
  138. up LittleDraw you should be able to see the line change after you press
  139. the draw button.
  140.  
  141.    
  142. Summary:
  143.  
  144. It is now easy for you to integrate powerful postscript drawing directly into
  145. your programs.  Take a look at Adobe's "Tutorial and Cookbook" and try some of
  146. the examples in there.
  147.  
  148.